package com.example.shirotest.utils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.Locale;
import java.util.regex.Pattern;

/**
 * 日期工具类
 */
public class DateUtil {

    /**
     * 获取今天
     *
     * @return String
     */
    public static String getToday() {
        return new SimpleDateFormat("yyyy-MM-dd").format(new Date());
    }

    /**
     * 获取昨天
     *
     * @return String
     */
    public static String getYestoday() {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DATE, -1);
        Date time = cal.getTime();
        return new SimpleDateFormat("yyyy-MM-dd").format(time);
    }

    /**
     * 获取本月开始日期
     *
     * @return String
     **/
    public static String getMonthStart() {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH, 0);
        cal.set(Calendar.DAY_OF_MONTH, 1);
        Date time = cal.getTime();
        return new SimpleDateFormat("yyyy-MM-dd").format(time) + " 00:00:00";
    }

    /**
     * 获取本月最后一天
     *
     * @return String
     **/
    public static String getMonthEnd() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
        Date time = cal.getTime();
        return new SimpleDateFormat("yyyy-MM-dd").format(time) + " 23:59:59";
    }

    /**
     * 获取本周的第一天
     *
     * @return String
     **/
    public static String getWeekStart() {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.WEEK_OF_MONTH, 0);
        cal.set(Calendar.DAY_OF_WEEK, 2);
        Date time = cal.getTime();
        return new SimpleDateFormat("yyyy-MM-dd").format(time) + " 00:00:00";
    }

    /**
     * 获取本周的最后一天
     *
     * @return String
     **/
    public static String getWeekEnd() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.DAY_OF_WEEK, cal.getActualMaximum(Calendar.DAY_OF_WEEK));
        cal.add(Calendar.DAY_OF_WEEK, 1);
        Date time = cal.getTime();
        return new SimpleDateFormat("yyyy-MM-dd").format(time) + " 23:59:59";
    }

    /**
     * 获取本年的第一天
     *
     * @return String
     **/
    public static String getYearStart() {
        return new SimpleDateFormat("yyyy").format(new Date()) + "-01-01";
    }

    /**
     * 获取本年的最后一天
     *
     * @return String
     **/
    public static String getYearEnd() {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.MONTH, calendar.getActualMaximum(Calendar.MONTH));
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
        Date currYearLast = calendar.getTime();
        return new SimpleDateFormat("yyyy-MM-dd").format(currYearLast) + " 23:59:59";
    }

    /**
     * 获取现在的日期时间
     *
     * @return String
     */
    public static String getNow() {
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
    }

    public static String getNowAllString() {
        return new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 E").format(new Date());
    }

    /**
     * 将 Date原始格式"EEE MMM dd HH:mm:ss Z yyyy"转成指定格式 "yyyy-MM-dd HH:mm:ss"
     *
     * @param str 待解析字符串 一般是执行Date的toString方法获得
     * @return 返回的字符串 yyyy-MM-dd HH:mm:ss格式
     */
    public static String parseOriTime(String str) {
        String sDate = "";
        SimpleDateFormat sdf1 = new SimpleDateFormat("EEE MMM dd HH:mm:ss Z yyyy", Locale.UK);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date date = sdf1.parse(str);
            sDate = sdf.format(date);
        } catch (Exception e) {
            System.out.println("日期转换失败:" + str);
        }
        return sDate;
    }

    /**
     * 将传入的Date格式化为"yyyy-MM-dd HH:mm:ss"形式，Date没有非空判断
     *
     * @param dateDate
     * @return
     */
    public static String dateToStrLong(Date date) {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString = formatter.format(date);
        return dateString;
    }

    /**
     * 将Date类型转换为字符串 "yyyy-MM-dd HH:mm:ss"形式 Date有非空判断
     *
     * @param date 日期类型
     * @return 日期字符串
     */
    public static String format(Date date) {
        if (date == null) {
            return "";
        }
        return format(date, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 将Calendar类型的时间转换为字符串 "yyyy-MM-dd HH:mm:ss"形式 Calendar有非空判断
     *
     * @param date
     * @return
     */
    public static String format(Calendar date) {
        if (date == null) {
            return "";
        }
        return format(date.getTime(), "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 将Date类型时间转换为指定格式的字符串，
     *
     * @param date    日期类型
     * @param pattern 日期格式化的字符串格式 可以不输入，不输入 默认是"yyyy-MM-dd HH:mm:ss"
     * @return 返回的日期字符串
     */
    public static String format(Date date, String pattern) {
        if (date == null) {
            return "";
        }
        if (pattern == null || pattern.equals("") || pattern.equals("null")) {
            pattern = "yyyy-MM-dd HH:mm:ss";
        }
        return new SimpleDateFormat(pattern).format(date);
    }

    /**
     * 将字符串类型时间转换为Date类型 字符串格式为"yyyy-MM-dd HH:mm:ss"
     *
     * @param date 字符串类型 格式为"yyyy-MM-dd HH:mm:ss"
     * @return 日期类型
     */
    public static Date format(String date) {
        return format(date, null);
    }

    /**
     * 将指定格式的字符串时间类型转换为Date类型
     *
     * @param date    字符串类型 时间字符串 不输入默认返回当前时间
     * @param pattern 时间字符串格式 不输入默认是yyyy-MM-dd HH:mm:ss
     * @return 日期类型
     */
    public static Date format(String date, String pattern) {
        if (pattern == null || pattern.equals("") || pattern.equals("null")) {
            pattern = "yyyy-MM-dd HH:mm:ss";
        }
        if (date == null || date.equals("") || date.equals("null")) {
            return new Date();
        }
        Date d = null;
        try {
            d = new SimpleDateFormat(pattern).parse(date);
        } catch (ParseException pe) {
            System.out.println("日期解析失败  date:" + date + "  pattern:" + pattern);
        }
        return d;
    }

    /**
     * 返回当前时间的格式化字符串 字符串格式为："yyyy-MM-dd HH:mm:ss"
     *
     * @return
     */
    public static String getCurrDate() {
        return format(new Date(), "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 根据传入的日期 解析出 该用何种SimpleDateFormat并返回对应的SimpleDateFormat
     *
     * @param dateStr 传入的日期字符串
     * @return
     */
    public static SimpleDateFormat getSimpleDateFormatPattern(String dateStr) {
        SimpleDateFormat format = null;
        if (Pattern.matches("\\d{4}-\\d{1,2}-\\d{1,2}", dateStr)) {
            format = new SimpleDateFormat("yyyy-MM-dd");
        } else if (Pattern.matches("\\d{4}\\d{2}\\d{2}", dateStr)) {
            format = new SimpleDateFormat("yyyyMMdd");
        } else if (Pattern.matches("\\d{4}年\\d{2}月\\d{2}日", dateStr)) {
            format = new SimpleDateFormat("yyyy年MM月dd日", Locale.CHINA);
        } else if (Pattern.matches("\\d{4}年\\d{1,2}月\\d{1,2}日", dateStr)) {
            format = new SimpleDateFormat("yyyy年M月d日", Locale.CHINA);
        } else if (Pattern.matches("\\d{1,2}\\w{3}\\d{4}", dateStr)) {
            format = new SimpleDateFormat("dMMMyyyy", Locale.ENGLISH);
        } else if (Pattern.matches("\\d{1,2}-\\w{3}-\\d{4}", dateStr)) {
            format = new SimpleDateFormat("d-MMM-yyyy", Locale.ENGLISH);
        } else if (Pattern.matches("\\d{4}-\\d{1,2}-\\d{1,2} \\d{1,2}:\\d{1,2}", dateStr)) {
            format = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        } else if (dateStr.length() > 20) {
            format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        } else {
            format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        }
        return format;
    }

    /**
     * 根据传入的日期字符串自动转化为Date类型的时间 不需要自己输入格式化方式字符串
     *
     * @param dateStr @return @throws
     *
     */
    public static Date parseDateByPattern(String dateStr) {
        SimpleDateFormat format = null;
        try {
            if (Pattern.matches("\\d{4}-\\d{2}-\\d{2}", dateStr)) {
                format = new SimpleDateFormat("yyyy-MM-dd");
                return format.parse(dateStr);
            } else if (Pattern.matches("\\d{4}/\\d{2}/\\d{2}", dateStr)) {
                format = new SimpleDateFormat("yyyy/MM/dd");
                return format.parse(dateStr);
            } else if (Pattern.matches("\\d{4}\\d{2}\\d{2}", dateStr)) {
                format = new SimpleDateFormat("yyyyMMdd");
                return format.parse(dateStr);
            } else if (Pattern.matches("\\d{4}年\\d{2}月\\d{2}日", dateStr)) {
                format = new SimpleDateFormat("yyyy年MM月dd日", Locale.CHINA);
                return format.parse(dateStr);
            } else if (Pattern.matches("\\d{4}年\\d{1,2}月\\d{1,2}日", dateStr)) {
                format = new SimpleDateFormat("yyyy年M月d日", Locale.CHINA);
                return format.parse(dateStr);
            } else if (Pattern.matches("\\d{4}/\\d{1,2}/\\d{1,2} \\d{2}:\\d{2}", dateStr)) {
                format = new SimpleDateFormat("yyyy/M/d HH:mm", Locale.CHINA);
                return format.parse(dateStr);
            } else if (Pattern.matches("\\d{4}\\.\\d{2}\\.\\d{2}", dateStr)) {
                format = new SimpleDateFormat("yyyy.MM.dd", Locale.CHINA);
                return format.parse(dateStr);
            } else if (Pattern.matches("\\d{4}年\\d{2}月", dateStr)) {
                format = new SimpleDateFormat("yyyy年MM月", Locale.CHINA);
                return format.parse(dateStr);
            } else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}", dateStr)) {
                format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);
                return format.parse(dateStr);
            } else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}", dateStr)) {
                format = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.CHINA);
                return format.parse(dateStr);
            } else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{3}", dateStr)) {
                format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.CHINA);
                return format.parse(dateStr);
            } else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{2}", dateStr)) {
                format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SS", Locale.CHINA);
                return format.parse(dateStr);
            } else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{1}", dateStr)) {
                format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.S", Locale.CHINA);
                return format.parse(dateStr);
            } else if (Pattern.matches("\\d{2}:\\d{2}", dateStr)) {
                format = new SimpleDateFormat("HH:mm", Locale.CHINA);
                return format.parse(dateStr);
            }
        } catch (Exception e) {
            System.out.println("日期字符串：<<" + dateStr + ">>转换为Date失败......");
        }
        return null;
    }

    /**
     * 根据传入的long数据给出这个数据有几天，几小时，几分和几秒
     *
     * 示例 输入 343039300 返回 3天23小时17分钟19秒
     *
     * @param milliSeconds long形数据
     * @return
     */
    public static String getTimeMilisecondDesc(long milliSeconds) {
        long days = milliSeconds / (1000 * 60 * 60 * 24);
        milliSeconds = milliSeconds - (days * 24 * 60 * 60 * 1000);
        long hours = milliSeconds / (1000 * 60 * 60);
        milliSeconds = milliSeconds - (hours * 60 * 60 * 1000);
        long minutes = milliSeconds / (1000 * 60);
        milliSeconds = milliSeconds - (minutes * 60 * 1000);
        long seconds = milliSeconds / (1000);

        StringBuffer sb = new StringBuffer();
        if (days != 0) {
            sb.append(days + "天");
        }
        if (hours != 0) {
            sb.append(hours + "小时");
        }
        if (minutes != 0) {
            sb.append(minutes + "分钟");
        }
        if (seconds != 0) {
            sb.append(seconds + "秒");
        }
        return sb.toString();
    }

    /**
     * 取得指定日期所在周的第一天 此处认为星期一是一周的第一天 时间是00:00:00
     *
     * @param date
     * @return
     */
    public static Date getFirstDayOfWeek(Date date) {
        Calendar c = clearDate(date, 4);
        c.setFirstDayOfWeek(Calendar.MONDAY);
        c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday
        return c.getTime();
    }

    /**
     * 取得指定日期所在周的最后一天 此处认为星期日是最后一天 时间到23:59:59 示例： 输入：20210225 返回：Sun Feb 28
     * 23:59:59 CST 2021
     *
     *
     * @param date
     * @return
     */
    public static Date getLastDayOfWeek(Date date) {
        Calendar c = clearDate(date, 4);
        c.setFirstDayOfWeek(Calendar.MONDAY);
        c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6);
        c.set(Calendar.HOUR_OF_DAY, 23);
        c.set(Calendar.MINUTE, 59);
        c.set(Calendar.SECOND, 59);
        c.set(Calendar.MILLISECOND, 000);
        return c.getTime();
    }

    /**
     * 取得指定日期所在周的起始时间 开始时间从00:00:00 结束时间是 23:59:59 此处认为星期一是一周第一天 星期日是一周最后一天 示例 传入
     * 20210225 返回 Mon Feb 22 00:00:00 CST 2021 Sun Feb 28 23:59:59 CST 2021
     *
     *
     * @param date 传入的日期
     *
     *
     * @return
     */
    public static Date[] getWeekLimit(Date date) {
        Date date1 = getFirstDayOfWeek(date);
        Date date2 = getLastDayOfWeek(date);
        return new Date[] { date1, date2 };
    }

    /**
     * 取得指定日期的当月起始时间 从00:00:00开始 到23:59:59 为止
     *
     * 示例 输入 20210225 输出 Mon Feb 01 00:00:00 CST 2021 Sun Feb 28 23:59:59 CST 2021
     *
     * @param date 指定日期时间
     * @return
     */
    public static Date[] getMonthLimit(Date date) {
        Calendar cal = clearDate(date, 5);
        Date date1 = cal.getTime();

        cal.add(Calendar.MONTH, 1);
        cal.add(Calendar.SECOND, -1);
        Date date2 = cal.getTime();

        return new Date[] { date1, date2 };
    }

    /**
     * 取得指定日期的当年起始时间 从00:00:00开始 到23:59:59 为止
     *
     * 示例：输入：20210225 输出：Fri Jan 01 00:00:00 CST 2021 Fri Dec 31 23:59:59 CST 2021
     *
     * @param date 指定日期时间
     * @return
     */
    public static Date[] getYearLimit(Date date) {
        Calendar cal = clearDate(date, 6);
        Date date1 = cal.getTime();

        cal.add(Calendar.YEAR, 1);
        cal.add(Calendar.SECOND, -1);
        Date date2 = cal.getTime();

        return new Date[] { date1, date2 };
    }

    /**
     * 取得指定日期当月的起始时间字符串 格式是：yyyy-MM-dd HH:mm:ss
     *
     * @param date
     * @return
     */
    public static String[] getMonthLimitStr(Date date) {
        Date[] rtDateArray = getMonthLimit(date);
        return new String[] { getDateTimeStr(rtDateArray[0]), getDateTimeStr(rtDateArray[1]) };
    }

    /**
     * 取得指定日期当年的起始时间串 格式是：yyyy-MM-dd HH:mm:ss
     *
     * @param date
     * @return
     */
    public static String[] getYearLimitStr(Date date) {
        Date[] rtDateArray = getYearLimit(date);
        return new String[] { getDateTimeStr(rtDateArray[0]), getDateTimeStr(rtDateArray[1]) };
    }

    /**
     * 给定的日期字符串，得出该日期字符串偏移多少天后的日期时间
     *
     * @param dateStr 日期字符串
     * @param dayCnt  偏移天数
     * @return 偏移后日期
     */
    public static Date getDayAfter(String dateStr, int dayCnt) {
        return getDayAfter(parseDate(dateStr), dayCnt);
    }

    /**
     * 给定日期，得出该日期偏移多少天后的日期
     *
     * @param date   给定日期
     * @param dayCnt 偏移天数
     * @return
     */
    public static Date getDayAfter(Date date, int dayCnt) {
        GregorianCalendar cal = new GregorianCalendar();
        cal.setTime(date);
        cal.add(Calendar.DATE, dayCnt);
        return cal.getTime();
    }

    /**
     * 给定日期，设置偏移多少秒后日期
     *
     * @param date      给定的日期
     * @param secondCnt 偏移秒数
     * @return 具体偏移后日期
     */
    public static Date getSecondAfter(Date date, int secondCnt) {
        GregorianCalendar cal = new GregorianCalendar();
        cal.setTime(date);
        cal.add(Calendar.SECOND, secondCnt);
        return cal.getTime();
    }

    /**
     * 指定日期偏移指定小时后的日期
     *
     * @param date    指定日期时间
     * @param hourCnt 指定小时数
     * @return 偏移后时间
     */
    public static Date getDayHourAfter(Date date, int hourCnt) {
        GregorianCalendar cal = new GregorianCalendar();
        cal.setTime(date);
        cal.add(Calendar.HOUR, hourCnt);
        return cal.getTime();
    }

    /**
     * 取得后多少月的时间
     *
     * @param date
     * @param monthCnt
     * @return
     */
    public static Date getMonthAfter(Date date, int monthCnt) {
        GregorianCalendar cal = new GregorianCalendar();
        cal.setTime(date);
        cal.add(Calendar.MONTH, monthCnt);
        return cal.getTime();
    }

    /**
     * 取得后多少年的时间
     *
     * @param date
     * @return
     */
    public static Date getYearAfter(Date date, int yearCnt) {
        GregorianCalendar cal = new GregorianCalendar();
        cal.setTime(date);
        cal.add(Calendar.YEAR, yearCnt);
        return cal.getTime();
    }

    /**
     * 取得指定日期多少天后所有日期的集合 不 包含指定日期的时间
     *
     * 比如 输入 20210225 2 输出：[Fri Feb 26 16:04:06 CST 2021, Sat Feb 27 16:04:06 CST
     * 2021]
     *
     * @param date   指定日期
     * @param dayCnt 指定天数
     * @return 日期集合
     */
    public static List<Date> getDayListAfter(Date date, int dayCnt) {
        List<Date> list = new ArrayList<Date>();
        GregorianCalendar cal = new GregorianCalendar();
        for (int i = 1; i <= dayCnt; i++) {
            cal.setTime(date);
            cal.add(Calendar.DATE, i);
            list.add(cal.getTime());
        }
        return list;
    }

    /**
     * 根据传入的日期字符串，给出该日期指定天数后的日期 实际就是日期相加减
     *
     * @param dateStr 日期字符串
     * @param dayCnt  指定天数
     * @return
     */
    public static Date getDayDiff(String dateStr, int dayCnt) {
        return getDayDiff(parseDate(dateStr), dayCnt);
    }

    /**
     * 根据传入的指定日期，给出该日期指定天数后的日期
     *
     * @param date   指定日期
     * @param dayCnt 指定天数
     * @return
     */
    public static Date getDayDiff(Date date, int dayCnt) {
        GregorianCalendar cal = new GregorianCalendar();
        cal.setTime(date);
        cal.add(Calendar.DATE, dayCnt);
        return cal.getTime();
    }

    /**
     * 取得今天开始时间 00:00:00
     *
     * @param date
     * @return
     */
    public static Date getStartToday() {

        Calendar todayStart = Calendar.getInstance();
        todayStart.set(Calendar.HOUR_OF_DAY, 0);
        todayStart.set(Calendar.MINUTE, 0);
        todayStart.set(Calendar.SECOND, 0);
        todayStart.set(Calendar.MILLISECOND, 0);
        return todayStart.getTime();
    }

    /**
     * 取得今天23:59:59秒时间
     *
     * @param date
     * @return
     */
    public static Date getEndToday() {
        Calendar todayEnd = Calendar.getInstance();
        todayEnd.set(Calendar.HOUR_OF_DAY, 23);
        todayEnd.set(Calendar.MINUTE, 59);
        todayEnd.set(Calendar.SECOND, 59);
        todayEnd.set(Calendar.MILLISECOND, 999);
        return todayEnd.getTime();
    }

    /**
     * 取得昨天的开始时间 00:00:00
     *
     * @param date
     * @return
     */
    public static Date getStatusYestday() {

        Calendar tempStart = Calendar.getInstance();
        Date start = new Date();

        tempStart.setTime(start);
        tempStart.set(Calendar.HOUR_OF_DAY, 0);
        tempStart.set(Calendar.MINUTE, 0);
        tempStart.set(Calendar.SECOND, 0);
        tempStart.set(Calendar.MILLISECOND, 0);
        tempStart.add(Calendar.DAY_OF_YEAR, -1);
        Date time = tempStart.getTime();

        return time;
    }

    /**
     * 取得昨天结束时间 23:59:59
     *
     * @param date
     * @return
     */
    public static Date getEndYestday() {

        Calendar tempEnd = Calendar.getInstance();
        Date end = new Date();

        tempEnd.setTime(end);
        tempEnd.set(Calendar.HOUR_OF_DAY, 0);
        tempEnd.set(Calendar.MINUTE, 0);
        tempEnd.set(Calendar.SECOND, 0);
        tempEnd.set(Calendar.MILLISECOND, 0);
        tempEnd.add(Calendar.SECOND, -1);
        Date time = tempEnd.getTime();
        return time;
    }

    /**
     * 取得前7天开始时间 包含今天 比如 20210303 返回 20210225 00:00:00
     *
     *
     * @param date
     * @return
     */
    public static Date getStatus7Days() {

        Calendar tempEnd = Calendar.getInstance();
        Date end = new Date();

        tempEnd.setTime(end);
        tempEnd.set(Calendar.HOUR_OF_DAY, 0);
        tempEnd.set(Calendar.MINUTE, 0);
        tempEnd.set(Calendar.SECOND, 0);
        tempEnd.set(Calendar.MILLISECOND, 0);
        tempEnd.add(Calendar.DAY_OF_YEAR, -6);
        Date time = tempEnd.getTime();

        return time;

    }


    /**
     * 取得前7天结束时间 包含今天 比如 20210303 返回 20210225 23:59:59
     *
     * @param date
     * @return
     */
    public static Date getEnd7Days() {

        Calendar tempEnd = Calendar.getInstance();
        Date end = new Date();

        tempEnd.setTime(end);
        tempEnd.set(Calendar.HOUR_OF_DAY, 0);
        tempEnd.set(Calendar.MINUTE, 0);
        tempEnd.set(Calendar.SECOND, 0);
        tempEnd.set(Calendar.MILLISECOND, 0);
        tempEnd.add(Calendar.DAY_OF_YEAR, -5);
        tempEnd.add(Calendar.SECOND, -1);
        Date time = tempEnd.getTime();

        return time;

    }

//	public static void main(String[] args) {
//		System.out.println(getEnd7Days());
//	}

    /**
     * 取得前30天的开始时间 包含今天 比如 20210304 返回 20210203 00:00:00
     *
     * @param date
     * @return
     */
    public static Date getStatus30Days() {
        Calendar tempEnd = Calendar.getInstance();
        Date end = new Date();

        tempEnd.setTime(end);
        tempEnd.set(Calendar.HOUR_OF_DAY, 0);
        tempEnd.set(Calendar.MINUTE, 0);
        tempEnd.set(Calendar.SECOND, 0);
        tempEnd.set(Calendar.MILLISECOND, 0);
        tempEnd.add(Calendar.DAY_OF_YEAR, -29);
        Date time = tempEnd.getTime();

        return time;
    }

//	public static void main(String[] args) {
//		System.out.println(getStatus30Days());
//	}

    /**
     * 取得指定日期 23:59:59的时间 解析失败返回当前时间
     *
     * @param date 指定日期
     * @return 指定日期 23:59:59的时间
     */
    public static Date getMongoDate(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar ca = Calendar.getInstance();
        ca.setTime(date);
        ca.set(Calendar.HOUR_OF_DAY, 23);
        ca.set(Calendar.MINUTE, 59);
        ca.set(Calendar.SECOND, 59);
        ca.set(Calendar.MILLISECOND, 999);
        try {
            return sdf.parse(sdf.format(ca.getTime()));
        } catch (ParseException e) {
            System.out.println("日期解析错误......");
        }
        return new Date();
    }

//	public static void main(String[] args) {
//		System.out.println(getMongoDate(new Date()));
//	}

    /**
     * 根据传入的日期字符串取得前一天的时间字符串 例如：传入 20200102 返回 2020-01-01 00:00:00 传入2020-01-02
     * 10:23:43 返回2020-01-01 10:23:43 字符串格式为：yyyy-MM-dd HH:mm:ss
     *
     * @param dateStr
     * @return
     */
    public static String getYestdayStr(String dateStr) {
        return getYestdayStr(parseDate(dateStr));
    }
//
//	public static void main(String[] args) {
//		System.out.println(getYestdayStr("2020-01-02 10:23:43"));
//	}

    /**
     * 取得指定日期 前一天的时间字符串 字符串格式为：yyyy-MM-dd HH:mm:ss
     *
     * @param date
     * @return
     */
    public static String getYestdayStr(Date date) {
        GregorianCalendar cal = new GregorianCalendar();
        cal.setTime(date);
        cal.add(Calendar.DATE, -1);
        return getDateTimeStr(cal.getTime());
    }

//	public static void main(String[] args) {
//		System.out.println(getYestdayStr(new Date()));
//	}

    /**
     * 根据传入的日期和参数将日期对应字段后面所有日期字段清零 参数对应字段说明：1=毫秒, 2=秒, 3=分钟, 4=小时, 5=天, 6=月份
     * 返回的是Calendar类型
     *
     * 样例: 1 Thu Mar 04 10:38:25 CST 2021 2 Thu Mar 04 10:38:00 CST 2021 3 Thu Mar
     * 04 10:00:00 CST 2021 4 Thu Mar 04 00:00:00 CST 2021 5 Mon Mar 01 00:00:00 CST
     * 2021 6 Fri Jan 01 00:00:00 CST 2021
     *
     * @param date     传入的日期时间
     * @param clearNum 1=毫秒, 2=秒, 3=分钟, 4=小时, 5=天, 6=月份
     * @return
     */
    public static Calendar clearDate(Date date, int clearNum) {
        Calendar cal = new GregorianCalendar();
        cal.setTime(date);
        // 毫秒
        if (clearNum > 0) {
            cal.set(Calendar.MILLISECOND, 0);
        }
        // 秒

        if (clearNum > 1) {
            cal.set(Calendar.SECOND, 0);
        }
        // 分钟
        if (clearNum > 2) {
            cal.set(Calendar.MINUTE, 0);
        }
        // 小时
        if (clearNum > 3) {
            cal.set(Calendar.HOUR_OF_DAY, 0);
        }
        // 天

        if (clearNum > 4) {
            cal.set(Calendar.DATE, 1);
        }
        // 月份
        if (clearNum > 5) {
            cal.set(Calendar.MONTH, 0);
        }
        return cal;
    }

    /**
     * 根据传入的字符串和字符串格式化类型将字符串转化为Date时间
     *
     * @param dateStr   日期字符串
     * @param formatStr 格式化形式
     * @return
     */
    public static Date parseDate(String formatStr, String dateStr) throws ParseException {
        SimpleDateFormat format = new SimpleDateFormat(formatStr);
        return format.parse(dateStr);
    }

    /**
     * 根据传入的字符串和字符串格式化类型将字符串转化为Calendar时间
     *
     * @param formatStr 格式化形式
     * @param dateStr   日期字符串
     * @return
     */
    public static Calendar parseCalendar(String formatStr, String dateStr) {
        Calendar c = Calendar.getInstance();
        try {
            c.setTime(parseDate(formatStr, dateStr));
        } catch (Exception e) {
            return null;
        }
        return c;
    }

    /**
     *
     * 根据传入的字符串将字符串转化为Calendar时间
     *
     * @param dateStr 传入的时间字符串
     * @return
     */
    public static Calendar parseCalendar(String dateStr) {
        Calendar c = Calendar.getInstance();
        try {
            c.setTime(parseDateByPattern(dateStr));
        } catch (Exception e) {
            return null;
        }
        return c;
    }

    /**
     * 把指定字符串转化为Date
     *
     * @param dateStr 指定的字符串
     * @return
     */
    public static Date parseDate(String dateStr) {
        if (dateStr == null || "".equals(dateStr)) {
            return null;
        }

        SimpleDateFormat format = null;
        if (Pattern.matches("\\d{4}-\\d{1,2}-\\d{1,2}", dateStr)) {
            format = new SimpleDateFormat("yyyy-MM-dd");
        } else if (Pattern.matches("\\d{4}\\d{2}\\d{2}", dateStr)) {
            format = new SimpleDateFormat("yyyyMMdd");
        } else if (Pattern.matches("\\d{4}年\\d{2}月\\d{2}日", dateStr)) {
            format = new SimpleDateFormat("yyyy年MM月dd日", Locale.CHINA);
        } else if (Pattern.matches("\\d{4}年\\d{1,2}月\\d{1,2}日", dateStr)) {
            format = new SimpleDateFormat("yyyy年M月d日", Locale.CHINA);
        } else if (Pattern.matches("\\d{1,2}\\w{3}\\d{4}", dateStr)) {
            format = new SimpleDateFormat("dMMMyyyy", Locale.ENGLISH);
        } else if (Pattern.matches("\\d{1,2}-\\w{3}-\\d{4}", dateStr)) {
            format = new SimpleDateFormat("d-MMM-yyyy", Locale.ENGLISH);
        } else if (dateStr.length() > 20) {
            format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
        } else {
            format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        }

        try {
            return format.parse(dateStr);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 取得指定时间的时间串，格式为 yyyy-MM-dd HH:mm:ss
     *
     * @param date 指定时间
     * @return 格式化后时间字符串
     */
    public static String getDateTimeStr(Date date) {
        if (date == null) {
            return getCurDateTimeStr();
        }
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date);
    }

    /**
     * 取得当前的时间，格式为 yyyy-MM-dd HH:mm:ss
     *
     * @return
     */
    public static String getCurDateTimeStr() {
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
    }

    /**
     * 根据传入的年份，给出该年的最大周
     *
     * @param year
     * @return
     */
    public static int getMaxWeekOfYear(int year) {
        Calendar c = new GregorianCalendar();
        c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
        return getWeekOfYear(c.getTime());
    }

    /**
     * 获取指定日期当前周
     *
     * @param date
     * @return
     */
    public static int getWeekOfYear(Date date) {
        Calendar c = new GregorianCalendar();
        c.setFirstDayOfWeek(Calendar.MONDAY); // 星期一为一周第一天
        c.setMinimalDaysInFirstWeek(7); // 设置在一年中第一个星期所需最少天数为7天 这样设置时如果新年第一周不满7天，则归属去年最后一周，以满足7天的时间作为第一周
        c.setTime(date);
        return c.get(Calendar.WEEK_OF_YEAR);
    }

    /**
     *
     * 返回值说明:返回一个Calendar数组，长度为2 分别是开始日期和结束日期 星期一作为一周的开始 第一周是完整周 不完整的几天算去年最后一周
     *
     * @param year    年分 例如 2014
     * @param weeknum 第几周 例如33
     * @return
     *
     */
    public static Calendar[] getStartAndEndDate(int year, int weeknum) {

        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, year);
        cal.set(Calendar.WEEK_OF_YEAR, weeknum);
        cal.setFirstDayOfWeek(Calendar.MONDAY); // 星期一为一周第一天
        cal.setMinimalDaysInFirstWeek(7); // 设置在一年中第一个星期所需最少天数为7天 这样设置时如果新年第一周不满7天，则归属去年最后一周，以满足7天的时间作为第一周
        int nw = cal.get(Calendar.DAY_OF_WEEK);
        Calendar start = (Calendar) cal.clone();
        Calendar end = (Calendar) cal.clone();
        start.add(Calendar.DATE, 1 - nw + 1);
        end.add(Calendar.DATE, 7 - nw + 1);
        Calendar[] darr = { start, end };
        return darr;
    }

    /**
     * 获取当期日期的一周 开始和结束日期 返回一个Calendar数组，长度为2 分别是开始日期和结束日期 星期一作为一周的开始
     *
     * @return
     */
    public static Calendar[] getCurrStartEndDate() {
        Calendar cal = Calendar.getInstance();
        // 向后推一天（从星期一到周末）
        cal.add(Calendar.DATE, -1);
        int nw = cal.get(Calendar.DAY_OF_WEEK);
        Calendar start = (Calendar) cal.clone();
        Calendar end = (Calendar) cal.clone();
        start.add(Calendar.DATE, 1 - nw + 1);
        end.add(Calendar.DATE, 7 - nw + 1);
        Calendar[] darr = { start, end };
        return darr;
    }

    /**
     * 获取当期日期的一周 开始至结束日期 返回一个Calendar数组，长度为7 星期一作为一周的开始
     *
     * @return
     */
    public static Calendar[] getCurrStartAndEndOfWeek() {
        Calendar cal = Calendar.getInstance();
        // 向后推一天（从星期一到周末）
        cal.add(Calendar.DATE, -1);
        int nw = cal.get(Calendar.DAY_OF_WEEK);
        Calendar start = (Calendar) cal.clone();
        start.add(Calendar.DATE, 1 - nw + 1);
        Calendar tuesday = (Calendar) cal.clone();// 周二
        tuesday.add(Calendar.DATE, 2 - nw + 1);
        Calendar wednesday = (Calendar) cal.clone();// 周三
        wednesday.add(Calendar.DATE, 3 - nw + 1);
        Calendar thursday = (Calendar) cal.clone();// 周四
        thursday.add(Calendar.DATE, 4 - nw + 1);
        Calendar friday = (Calendar) cal.clone();// 周五
        friday.add(Calendar.DATE, 5 - nw + 1);
        Calendar saturday = (Calendar) cal.clone();// 周六
        saturday.add(Calendar.DATE, 6 - nw + 1);
        Calendar end = (Calendar) cal.clone();
        end.add(Calendar.DATE, 7 - nw + 1);
        Calendar[] darr = { start, tuesday, wednesday, thursday, friday, saturday, end };
        return darr;
    }

    /**
     * 获取指定日期的一周 开始至结束日期 返回一个Calendar数组，长度为7 星期一作为一周的开始
     *
     * @param date 指定日期
     * @return
     */
    public static Calendar[] getStartAndEndOfWeekByDate(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        // 向后推一天（从星期一到周末）
        cal.add(Calendar.DATE, -1);
        int nw = cal.get(Calendar.DAY_OF_WEEK);
        Calendar start = (Calendar) cal.clone();
        start.add(Calendar.DATE, 1 - nw + 1);
        Calendar tuesday = (Calendar) cal.clone();// 周二
        tuesday.add(Calendar.DATE, 2 - nw + 1);
        Calendar wednesday = (Calendar) cal.clone();// 周三
        wednesday.add(Calendar.DATE, 3 - nw + 1);
        Calendar thursday = (Calendar) cal.clone();// 周四
        thursday.add(Calendar.DATE, 4 - nw + 1);
        Calendar friday = (Calendar) cal.clone();// 周五
        friday.add(Calendar.DATE, 5 - nw + 1);
        Calendar saturday = (Calendar) cal.clone();// 周六
        saturday.add(Calendar.DATE, 6 - nw + 1);
        Calendar end = (Calendar) cal.clone();
        end.add(Calendar.DATE, 7 - nw + 1);
        Calendar[] darr = { start, tuesday, wednesday, thursday, friday, saturday, end };
        return darr;
    }

    /**
     * 算出俩个时间，所间隔的多少天
     *
     * @param startDate
     * @param endDate
     * @return
     */
    public static Long getDaysBetween(Date startDate, Date endDate) {
        Calendar fromCalendar = Calendar.getInstance();
        fromCalendar.setTime(startDate);
        fromCalendar.set(Calendar.HOUR_OF_DAY, 0);
        fromCalendar.set(Calendar.MINUTE, 0);
        fromCalendar.set(Calendar.SECOND, 0);
        fromCalendar.set(Calendar.MILLISECOND, 0);

        Calendar toCalendar = Calendar.getInstance();
        toCalendar.setTime(endDate);
        toCalendar.set(Calendar.HOUR_OF_DAY, 0);
        toCalendar.set(Calendar.MINUTE, 0);
        toCalendar.set(Calendar.SECOND, 0);
        toCalendar.set(Calendar.MILLISECOND, 0);

        return (toCalendar.getTime().getTime() - fromCalendar.getTime().getTime()) / (1000 * 60 * 60 * 24);
    }

    /**
     * 两个时间相差多少天多少小时多少分多少秒
     *
     * @param startDate 时间参数 1 格式：1990-01-01 12:00:00
     * @param endDate   时间参数 2 格式：2009-01-01 12:00:00
     * @return long[] 返回值为：{天, 时, 分, 秒}
     */
    public static long[] getDaysBetweenmm(String startDate, String endDate) {
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date one;
        Date two;
        long day = 0;
        long hour = 0;
        long min = 0;
        long sec = 0;
        try {
            one = df.parse(startDate);
            two = df.parse(endDate);
            long time1 = one.getTime();
            long time2 = two.getTime();
            long diff;
            if (time1 < time2) {
                diff = time2 - time1;
            } else {
                diff = time1 - time2;
            }
            day = diff / (24 * 60 * 60 * 1000);
            hour = (diff / (60 * 60 * 1000) - day * 24);
            min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
            sec = (diff / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        long[] times = { day, hour, min, sec };
        return times;
    }

    /**
     * 根据指定的月字符串算出月初和月未的时间，精确到秒 实例：输入：2020-01 输出：Wed Jan 01 00:00:00 CST 2020 Fri
     * Jan 31 23:59:59 CST 2020
     *
     *
     * @param monthStr 格式为:2020-01形式
     * @return 月初和月末时间数组
     */
    public static Date[] getDatetimeMonthLimit(String monthStr) {
        String start = monthStr + "-01 00:00:00";
        Date startTime = DateUtil.format(start);

        Calendar cal = Calendar.getInstance();
        cal.setTime(startTime);
        cal.set(Calendar.DATE, cal.getActualMaximum(Calendar.DATE) + 1);
        cal.add(Calendar.SECOND, -1);
        Date endTime = cal.getTime();
        return new Date[] { startTime, endTime };
    }

    /**
     * 根据指定的月字符串算出上月月初和月未的时间，精确到秒
     *
     * @param monthStr 格式为:2020-01形式
     * @return 上月月初和月未的时间
     */
    public static Date[] getDatetimePreMonthLimit(String monthStr) {
        String start = monthStr + "-01 00:00:00";
        Date startTime = DateUtil.format(start);

        Calendar cal = Calendar.getInstance();
        cal.setTime(startTime);
        cal.add(Calendar.MONTH, -1);
        startTime = cal.getTime();

        cal.set(Calendar.DATE, cal.getActualMaximum(Calendar.DATE));
        Date endTime = new Date(cal.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
        return new Date[] { startTime, endTime };
    }

    /**
     * 根据指定的天字符串算出天开始和天结束的时间，精确到秒
     *
     * @param day 指定的天字符串 格式为：2020-01-01
     * @return 算出天开始和天结束的时间
     */
    public static Date[] getDatetimeDayLimit(String day) {
        String startStr = day + " 00:00:00";
        Date start = DateUtil.parseDate(startStr);
        return new Date[] { start, new Date(start.getTime() + 24 * 60 * 60 * 1000l - 1l) };
    }

    /**
     * 根据指定的天字符串算出昨天开始和昨天结束的时间，精确到秒
     *
     * @param day 指定的天字符串 格式为：2020-01-01
     * @return 算出昨天开始和昨天结束的时间
     */
    public static Date[] getDatetimePreDayLimit(String day) {
        String startStr = day + " 00:00:00";
        Date start = new Date(DateUtil.parseDate(startStr).getTime() - 24 * 60 * 60 * 1000l);
        return new Date[] { start, new Date(start.getTime() + 24 * 60 * 60 * 1000l - 1l) };
    }

    /**
     *
     * 根据传入的日期，判断日期是第几季度 1 第一季度 2 第二季度 3 第三季度 4 第四季度
     *
     * @param date 传入的日期
     * @return 季度数
     */
    public static int getSeason(Date date) {

        int season = 0;

        Calendar c = Calendar.getInstance();
        c.setTime(date);
        int month = c.get(Calendar.MONTH);
        switch (month) {
            case Calendar.JANUARY:
            case Calendar.FEBRUARY:
            case Calendar.MARCH:
                season = 1;
                break;
            case Calendar.APRIL:
            case Calendar.MAY:
            case Calendar.JUNE:
                season = 2;
                break;
            case Calendar.JULY:
            case Calendar.AUGUST:
            case Calendar.SEPTEMBER:
                season = 3;
                break;
            case Calendar.OCTOBER:
            case Calendar.NOVEMBER:
            case Calendar.DECEMBER:
                season = 4;
                break;
            default:
                break;
        }
        return season;
    }

    /**
     * 根据指定的年份和季度 算出季度初和季度未的时间，精确到秒
     *
     * @param year    年份
     * @param nSeason 第几季度
     * @return 季度开始和结束时间
     */
    public static Date[] getDatetimeSeasonLimit(int year, int nSeason) {
        Calendar c = Calendar.getInstance();
        Date[] season = new Date[2];
        c.set(year, Calendar.JANUARY, 1, 0, 0, 0);
        c.set(Calendar.MILLISECOND, 0);
        if (nSeason == 1) {// 第一季度
            c.set(Calendar.MONTH, Calendar.JANUARY);
            season[0] = c.getTime();
            c.set(Calendar.MONTH, Calendar.MARCH);
            c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
            season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
        } else if (nSeason == 2) {// 第二季度
            c.set(Calendar.MONTH, Calendar.APRIL);
            season[0] = c.getTime();
            c.set(Calendar.MONTH, Calendar.JUNE);
            c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
            season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
        } else if (nSeason == 3) {// 第三季度
            c.set(Calendar.MONTH, Calendar.JULY);
            season[0] = c.getTime();
            c.set(Calendar.MONTH, Calendar.SEPTEMBER);
            c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
            season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
        } else if (nSeason == 4) {// 第四季度
            c.set(Calendar.MONTH, Calendar.OCTOBER);
            season[0] = c.getTime();
            c.set(Calendar.MONTH, Calendar.DECEMBER);
            c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
            season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
        }

        return season;
    }

    /**
     * 根据指定的年份和季度 算出上一季度 季度初和季度未的时间，精确到秒
     *
     * @param year    年份
     * @param nSeason 第几季度
     * @return
     */
    public static Date[] getDatetimePreSeasonLimit(int year, int nSeason) {
        if (nSeason == 1) {
            nSeason = 4;
            year = year - 1;
        } else {
            nSeason = nSeason - 1;
        }
        return getDatetimeSeasonLimit(year, nSeason);
    }

    /**
     * 根据指定的年份数据算出年初和年未的时间，精确到秒
     *
     * @param year 年份
     * @return
     */
    public static Date[] getDatetimeYearLimit(int year) {
        Calendar c = Calendar.getInstance();
        Date[] res = new Date[2];
        c.set(Calendar.YEAR, year);
        c.set(Calendar.MONTH, Calendar.JANUARY);
        res[0] = clearDate(c.getTime(), 5).getTime();
        c.setTime(res[0]);
        c.set(Calendar.MONTH, Calendar.DECEMBER);
        c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
        res[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
        return res;
    }

    /**
     * 根据指定的年份数据算出去年年初和年未的时间，精确到秒
     *
     * @param year 年份
     * @return
     */
    public static Date[] getDatetimePreYearLimit(int year) {
        return getDatetimeYearLimit(year - 1);
    }

    /**
     * 日期相加减
     *
     * @param date
     * @param number 天数数量
     * @return
     */
    public static Date getNextDay(Date date, int number) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DAY_OF_MONTH, number);// +1今天的时间加一天
        date = calendar.getTime();
        return date;
    }

    /**
     * 计算俩个时间差多少天多少小时
     *
     * @param endDate 结束时间
     * @param nowDate 开始时间
     * @return 差几天的字符串
     */
    public static String getDatePoorHour(Date nowDate, Date endDate) {

        long nd = 1000 * 24 * 60 * 60l;
        long nh = 1000 * 60 * 60l;
        long nm = 1000 * 60l;
        // long ns = 1000;
        // 获得两个时间的毫秒时间差异
        long diff = endDate.getTime() - nowDate.getTime();
        // 计算差多少天
        long day = diff / nd;
        // 计算差多少小时
        long hour = (diff % nd) / nh;
        // 计算差多少分钟
        long min = (diff % nd % nh) / nm;
        // 计算差多少秒//输出结果
        // long sec = diff % nd % nh % nm / ns;
        return day + "天" + hour + "小时";
    }

    /**
     * 计算俩个时间差多少天多少小时多少分钟
     *
     * @param endDate 结束时间
     * @param nowDate 开始时间
     * @return
     */
    public static String getDatePoorMinute(Date nowDate, Date endDate) {

        long nd = 1000 * 24 * 60 * 60l;
        long nh = 1000 * 60 * 60l;
        long nm = 1000 * 60l;
        // long ns = 1000;
        // 获得两个时间的毫秒时间差异
        long diff = endDate.getTime() - nowDate.getTime();
        // 计算差多少天
        long day = diff / nd;
        // 计算差多少小时
        long hour = (diff % nd) / nh;
        // 计算差多少分钟
        long min = (diff % nd % nh) / nm;
        // 计算差多少秒//输出结果
        // long sec = diff % nd % nh % nm / ns;
        String tempStr = "";
        if (day > 0) {
            tempStr = day + "天";
        }
        if (hour > 0) {
            tempStr += hour + "小时";
        }
        if (min > 0) {
            tempStr += min + "分钟";
        }
        return tempStr;
    }

    /**
     * 计算俩个时间相差多少分钟
     *
     * @param endDate 结束时间
     * @param nowDate 开始时间
     * @return
     */
    public static long getDatePoorTotalMinute(Date nowDate, Date endDate) {
        long nm = 1000 * 60l;
        // long ns = 1000;
        // 获得两个时间的毫秒时间差异
        long diff = endDate.getTime() - nowDate.getTime();
        Long tempLong = diff / nm;
        return tempLong;
    }

    /**
     * 获取当前季度的开始时间
     *
     * @return
     */
    public static Date getCurrentQuarterStartTime() {
        Calendar c = Calendar.getInstance();
        int currentMonth = c.get(Calendar.MONTH) + 1;
        Date now = null;
        try {
            if (currentMonth >= 1 && currentMonth <= 3)
                c.set(Calendar.MONTH, 0);
            else if (currentMonth >= 4 && currentMonth <= 6)
                c.set(Calendar.MONTH, 3);
            else if (currentMonth >= 7 && currentMonth <= 9)
                c.set(Calendar.MONTH, 6);
            else if (currentMonth >= 10 && currentMonth <= 12)
                c.set(Calendar.MONTH, 9);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return clearDate(c.getTime(), 5).getTime();
    }

    /**
     * 获取当前季度的结束时间
     *
     * @return
     */
    public static Date getCurrentQuarterEndTime() {
        Calendar c = Calendar.getInstance();
        int currentMonth = c.get(Calendar.MONTH) + 1;
        try {
            if (currentMonth >= 1 && currentMonth <= 3) {
                c.set(Calendar.MONTH, 2);
                c.set(Calendar.DATE, 31);
            } else if (currentMonth >= 4 && currentMonth <= 6) {
                c.set(Calendar.MONTH, 5);
                c.set(Calendar.DATE, 30);
            } else if (currentMonth >= 7 && currentMonth <= 9) {
                c.set(Calendar.MONTH, 8);
                c.set(Calendar.DATE, 30);
            } else if (currentMonth >= 10 && currentMonth <= 12) {
                c.set(Calendar.MONTH, 11);
                c.set(Calendar.DATE, 31);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        c.set(Calendar.HOUR_OF_DAY, 23);
        c.set(Calendar.MINUTE, 59);
        c.set(Calendar.SECOND, 59);
        c.set(Calendar.MILLISECOND, 000);
        return c.getTime();
    }

    /**
     * 输入指定日期，给出该日期为星期几的字符串说明
     *
     * @param date
     * @return
     */
    public static String getWeek(Date date) {
        String[] weeks = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        int week_index = cal.get(Calendar.DAY_OF_WEEK) - 1;
        if (week_index < 0) {
            week_index = 0;
        }
        return weeks[week_index];
    }

    /**
     * 获取两个日期相隔天数 去掉时分秒，直接比对日
     *
     * @param fDate 开始时间
     * @param oDate 结束时间
     * @return 返回相差几天
     */
    public static int getIntervalOfDays(Date fDate, Date oDate) {
        if (null == fDate || null == oDate) {
            return -1;
        }
        fDate = DateUtil.clearDate(fDate, 4).getTime();
        oDate = DateUtil.clearDate(oDate, 4).getTime();
        long intervalMilli = oDate.getTime() - fDate.getTime();
        return (int) (intervalMilli / (24 * 60 * 60 * 1000));
    }

    /**
     * 获取指定时间的月份数据
     *
     * @param date 指定时间
     * @return 月份数据
     */
    public static int getMonth(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.MONTH) + 1;
    }

    /**
     * 获取指定时间的年份数据
     *
     * @param date
     * @return
     */
    public static int getYear(Date date) {
        Calendar now = Calendar.getInstance();
        now.setTime(date);
        return now.get(Calendar.YEAR);
    }

    /**
     * 获取指定时间几分钟后的时间字符串
     *
     * @param date   指定时间
     * @param minute 几分钟后数据
     * @return
     */
    public static String getTimeByMinute(Date date, int minute) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MINUTE, minute);
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(calendar.getTime());

    }

    /**
     *
     * 根据指定规则输出指定日期字符串的中文表示 接收日期格式字符转化为中文+日期格式 规则： 刚刚（5分钟前） ①如果开课时间为当天的日期，显示“今天+时+分”
     * ②如果开课时间为昨天的日期，显示“昨天+时+分” ③如果开课时间为前天的日期，显示“前天+时+分” ④如果开课时间为明天的日期，显示“明天+时+分”
     * ⑤如果开课时间为后天的日期，显示“后天+时+分” ⑥如果开课时间超出后天，并且还在当前周内，显示“本周X+时+分” ⑦其余日期均显示“月-日 时：分”
     * ⑧如果开课时间不是当前年，显示“年-月-日 时：分”
     *
     * @param date 指定日期字符串 格式为：yyyy-MM-dd HH:mm:ss
     * @return 指定日期字符串的中文表示
     */
    public static String transFinalFormationStringDate(String date) {
        long[] daysBetweenmm = getDaysBetweenmm(date, format(new Date()));
        if (daysBetweenmm[0] == 0 && daysBetweenmm[1] == 0 && daysBetweenmm[2] < 6) {
            return "刚刚";
        }
        return transFormationStringDate(date);
    }

    /**
     *
     * @param date
     * @return
     */
    public static String transFormationStringDate(String date) {
        Date now = new Date();
        SimpleDateFormat sss = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return transFormationStringDate(date, now, sss.format(now));

    }

    /**
     * 接收日期格式字符转化为中文+日期格式 规则：①如果开课时间为当天的日期，显示“今天+时+分” ②如果开课时间为昨天的日期，显示“昨天+时+分”
     * ③如果开课时间为前天的日期，显示“前天+时+分” ④如果开课时间为明天的日期，显示“明天+时+分” ⑤如果开课时间为后天的日期，显示“后天+时+分”
     * ⑥如果开课时间超出后天，并且还在当前周内，显示“本周X+时+分” ⑦其余日期均显示“月-日 时：分” ⑧如果开课时间不是当前年，显示“年-月-日 时：分”
     *
     * @param date
     * @return
     */
    public static String transFormationStringDate(String date, Date newDate, String newDateStr) {
        SimpleDateFormat sss = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            String yyyyStr = date.substring(0, 4);
            String mmStr = date.substring(5, 7);
            String ddStr = date.substring(8, 10);

            String hhStr = date.substring(11, 13);
            String MMStr = date.substring(14, 16);
            String ssStr = date.substring(17, 19);

            int yyyy = Integer.parseInt(yyyyStr);
            int mm = Integer.parseInt(mmStr);
            int dd = Integer.parseInt(ddStr);

            int hh = Integer.parseInt(hhStr);
            int MM = Integer.parseInt(MMStr);
            int ss = Integer.parseInt(ssStr);

            int yyyy1 = Integer.parseInt(newDateStr.substring(0, 4));
            int mm1 = Integer.parseInt(newDateStr.substring(5, 7));
            int dd1 = Integer.parseInt(newDateStr.substring(8, 10));

            if (yyyy != yyyy1) {// 如果开课时间不是当前年，显示“年-月-日 时：分”
                return yyyyStr + "-" + mmStr + "-" + ddStr + " " + hhStr + ":" + MMStr;
            }
            if (mm == mm1 && dd == dd1) {// 如果开课时间为当天的日期，显示“今天+时+
                return "今天" + " " + hhStr + ":" + MMStr;
            }
            Date allDate = sss.parse(date);
            Long daysBetween = getDaysBetween(newDate, allDate);
            if (daysBetween == -1) {// 如果开课时间为昨天的日期，显示“昨天+时+分”
                return "昨天" + " " + hhStr + ":" + MMStr;
            }
            if (daysBetween == -2) {// 如果开课时间为前天的日期，显示“前天+时+分”
                return "前天" + " " + hhStr + ":" + MMStr;
            }
            if (daysBetween == 1) {// 如果开课时间为明天的日期，显示“明天+时+分”
                return "明天" + " " + hhStr + ":" + MMStr;
            }
            if (daysBetween == 2) {// 如果开课时间为后天的日期，显示“后天+时+分”
                return "后天" + " " + hhStr + ":" + MMStr;
            }
            if (daysBetween > 2 || daysBetween < -2) {// 如果开课时间超出后天
                Date firstDayOfWeek1 = getFirstDayOfWeek(newDate);// 当前日期所在周的第一天
                Date firstDayOfWeek2 = getFirstDayOfWeek(allDate);// 传入日期所在周的第一天
                if (firstDayOfWeek1.getTime() == firstDayOfWeek2.getTime()) {// 并且还在当前周内，显示“本周X+时+分”
                    Long ad = getDaysBetween(firstDayOfWeek1, allDate);
                    switch (ad.intValue()) {
                        case 0:
                            return "本周一" + " " + hhStr + ":" + MMStr;
                        case 1:
                            return "本周二" + " " + hhStr + ":" + MMStr;
                        case 2:
                            return "本周三" + " " + hhStr + ":" + MMStr;
                        case 3:
                            return "本周四" + " " + hhStr + ":" + MMStr;
                        case 4:
                            return "本周五" + " " + hhStr + ":" + MMStr;
                        case 5:
                            return "本周六" + " " + hhStr + ":" + MMStr;
                        case 6:
                            return "本周日" + " " + hhStr + ":" + MMStr;
                    }
                }
            }
            // 其余日期均显示“月-日 时：分”
            return mmStr + "-" + ddStr + " " + hhStr + ":" + MMStr;
            // format(allDate,"MM-dd HH:mm");
        } catch (Exception e) {
            return "日期格式字符转化错误";
        }
    }

    /**
     * 获取指定时间根据格式化方式获取的各组成部分
     *
     *
     * @param date   指定时间
     * @param format 获取的部分 yyyy 年份 MM 月份 dd 日
     * @return
     */
    public static int getYMDDate(Date date, String format) {
        SimpleDateFormat sdf = null;
        try {
            if (format != null && format.length() > 0) {
                if ("yyyy".equals(format)) {
                    sdf = new SimpleDateFormat("yyyy");
                    String formatY = sdf.format(date);
                    return Integer.parseInt(formatY);
                } else if ("MM".equals(format)) {
                    sdf = new SimpleDateFormat("MM");
                    String formatY = sdf.format(date);
                    return Integer.parseInt(formatY);
                } else if ("dd".equals(format)) {
                    sdf = new SimpleDateFormat("dd");
                    String formatY = sdf.format(date);
                    return Integer.parseInt(formatY);
                }

            }
            return 0;
        } catch (Exception e) {
            return 0;
        }
    }

    /**
     *
     * 传入天、时、份、秒 获取当月指定天数后的指定时间
     *
     * @param hour   小时数
     * @param minute 分钟数
     * @param second 秒钟数
     * @param day    指定天数后
     * @return 指定时间
     */
    public static Date getNeedTime(int hour, int minute, int second, int day) {
        Calendar calendar = Calendar.getInstance();
        if (day != 0) {
            calendar.add(Calendar.DATE, day);
        }
        calendar.set(Calendar.HOUR_OF_DAY, hour);
        calendar.set(Calendar.MINUTE, minute);
        calendar.set(Calendar.SECOND, second);

        return calendar.getTime();
    }

}

